home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / share / hplip / pcard / photocard.py < prev   
Text File  |  2008-10-13  |  22KB  |  742 lines
  1. # -*- coding: utf-8 -*-
  2. #
  3. # (c) Copyright 2003-2007 Hewlett-Packard Development Company, L.P.
  4. #
  5. # This program is free software; you can redistribute it and/or modify
  6. # it under the terms of the GNU General Public License as published by
  7. # the Free Software Foundation; either version 2 of the License, or
  8. # (at your option) any later version.
  9. #
  10. # This program is distributed in the hope that it will be useful,
  11. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. # GNU General Public License for more details.
  14. #
  15. # You should have received a copy of the GNU General Public License
  16. # along with this program; if not, write to the Free Software
  17. # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18. #
  19.  
  20. # Std Lib
  21. import struct
  22. import time
  23. import fnmatch
  24. import mimetypes
  25. import array
  26.  
  27. # Local
  28. from base.g import *
  29. from base.codes import *
  30. from base import device, utils, exif
  31.  
  32. try:
  33.     import pcardext
  34. except ImportError:
  35.     if not os.getenv("HPLIP_BUILD"):
  36.         log.error("PCARDEXT could not be loaded. Please check HPLIP installation.")
  37.         sys.exit(1)
  38.  
  39. # Photocard command codes
  40. ACK = 0x0100
  41. NAK = 0x0101
  42. READ_CMD = 0x0010
  43. WRITE_CMD = 0x0020
  44.  
  45. SECTOR_SIZE = 512 # don't change this (TODO: impl. in pcardext)
  46.  
  47. # Photocard sector cache
  48. MAX_CACHE = 512 # units = no. sectors 
  49.  
  50. # PhotoCardFile byte cache
  51. # Used for thumbnails
  52. INITIAL_PCARDFILE_BUFFER = 20*SECTOR_SIZE 
  53. INCREMENTAL_PCARDFILE_BUFFER = 2*SECTOR_SIZE 
  54.  
  55. class PhotoCardFile:    
  56.     # File-like interface
  57.  
  58.     def __init__(self, pc, name=None):
  59.         self.pos = 0
  60.         self.closed = True
  61.         self.file_size = 0
  62.         self.pc = pc
  63.         self.buffer = array.array('c') 
  64.  
  65.         if name is not None:
  66.             self.open(name)
  67.  
  68.         self.buffer_size = INITIAL_PCARDFILE_BUFFER
  69.         self.buffer.fromstring(pcardext.read(self.name, 0, self.buffer_size))
  70.  
  71.  
  72.     def open(self, name):
  73.         self.closed = False
  74.         self.name = name
  75.  
  76.     def seek(self, offset, whence=0):
  77.         if whence == 0:
  78.             self.pos = offset
  79.         elif whence == 1:
  80.             self.pos += offset
  81.         elif whence == 2:
  82.             self.pos = self.file_size - offset
  83.         else:
  84.             return
  85.  
  86.  
  87.     def tell(self):
  88.         return self.pos
  89.  
  90.  
  91.     def read(self, size): 
  92.         if size > 0:
  93.             if self.pos + size < self.buffer_size:
  94.                 data = self.buffer[self.pos : self.pos + size].tostring()
  95.                 self.pos += size
  96.                 return data
  97.             else:
  98.                 # Read some more in from the card to satisfy the request
  99.                 while self.pos + size >= self.buffer_size:
  100.                     self.buffer.fromstring(pcardext.read(self.name, self.buffer_size, INCREMENTAL_PCARDFILE_BUFFER))
  101.                     self.buffer_size += INCREMENTAL_PCARDFILE_BUFFER
  102.                 return self.read(size)
  103.  
  104.  
  105.     def close(self):
  106.         self.closed = True
  107.         self.pos = 0
  108.  
  109.  
  110. class PhotoCard:
  111.  
  112.     def __init__(self, dev_obj=None, device_uri=None, printer_name=None):
  113.  
  114.         if dev_obj is None:
  115.             self.device = device.Device(device_uri, printer_name)
  116.             self.device.open()
  117.             self.close_device = True
  118.         else:
  119.             self.device = dev_obj
  120.             self.close_device = False
  121.  
  122.         self.dir_stack = utils.Stack()
  123.         self.current_dir = []
  124.         self.device_uri = self.device.device_uri
  125.         self.pcard_mounted = False
  126.         self.saved_pwd = []
  127.         self.sector_buffer = {}
  128.         self.sector_buffer_counts = {}
  129.         self.cache_flag = True
  130.         self.write_protect = False
  131.  
  132.         self.callback = None
  133.  
  134.         self.channel_opened = False
  135.  
  136.  
  137.     def START_OPERATION(self, name=''):
  138.         pass
  139.  
  140.     def END_OPERATION(self, name='', flag=True):
  141.         if self.channel_opened and flag:
  142.             self.close_channel()
  143.  
  144.     def set_callback(self, callback):
  145.         self.callback = callback
  146.  
  147.     def _read(self, sector, nsector): 
  148.         log.debug("read pcard sector: sector=%d count=%d" % (sector, nsector))
  149.  
  150.         if self.cache_flag:
  151.             for s in range(sector, sector+nsector):
  152.                 if s not in self.sector_buffer:
  153.                     break
  154.             else:
  155.                 buffer = ''
  156.                 for s in range(sector, sector+nsector):
  157.                     buffer = ''.join([buffer, self.sector_buffer[s]])
  158.                     log.debug("Cached sector read sector=%d" % s)
  159.                     count = self.sector_buffer_counts[s]
  160.                     self.sector_buffer_counts[s] = count+1
  161.  
  162.                     if self.callback is not None:
  163.                         self.callback()
  164.  
  165.                 #log.log_data(buffer)
  166.                 return buffer
  167.  
  168.         if self.callback is not None:
  169.             self.callback()
  170.  
  171.         if not self.channel_opened:
  172.             self.open_channel()
  173.  
  174.         log.debug("Normal sector read sector=%d count=%d" % (sector, nsector))
  175.         sectors_to_read = range(sector, sector+nsector)
  176.         request = struct.pack('!HH' + 'I'*nsector, READ_CMD, nsector, *sectors_to_read)
  177.         #log.log_data(request)
  178.         
  179.         if self.callback is not None:
  180.             self.callback()
  181.  
  182.         # send out request
  183.         bytes_written = self.device.writePCard(request)
  184.         log.debug("%d bytes written" % bytes_written)
  185.  
  186.         # read return code
  187.         data = self.device.readPCard(2)
  188.         #log.log_data(data)
  189.         code = struct.unpack('!H', data)[0]
  190.  
  191.         log.debug("Return code: %x" % code)
  192.  
  193.         if code == 0x0110:
  194.  
  195.             # read sector count and version
  196.             data = self.device.readPCard(6)
  197.             nsector_read, ver = struct.unpack('!IH', data)
  198.  
  199.             log.debug("code=0x%x, nsector=%d, ver=%d" % (code, nsector_read, ver))
  200.  
  201.             buffer, data_read, total_to_read = '', 0, nsector * SECTOR_SIZE
  202.  
  203.             while (data_read < total_to_read):
  204.                 data = self.device.readPCard(total_to_read)
  205.  
  206.                 data_read += len(data)
  207.                 buffer = ''.join([buffer, data])
  208.  
  209.                 if self.callback is not None:
  210.                     self.callback()            
  211.  
  212.             if self.cache_flag:
  213.                 i = 0
  214.  
  215.                 for s in range(sector, sector + nsector_read):
  216.                     self.sector_buffer[s] = buffer[i : i+SECTOR_SIZE]
  217.                     #log.debug("Sector %d data=\n%s" % (s, repr(self.sector_buffer[s])))
  218.                     count = self.sector_buffer_counts.get(s, 0)
  219.                     self.sector_buffer_counts[s] = count+1
  220.                     i += SECTOR_SIZE
  221.  
  222.                     if self.callback is not None:
  223.                         self.callback()            
  224.  
  225.                 self._check_cache(nsector)
  226.  
  227.             #log.log_data(buffer)
  228.             return buffer
  229.         else:
  230.             log.error("Error code: %d" % code)
  231.             return ''
  232.  
  233.     def _write(self, sector, nsector, buffer):
  234.  
  235.         #log.debug("write pcard sector: sector=%d count=%d len=%d data=\n%s" % (sector, nsector, len(buffer), repr(buffer)))
  236.         log.debug("write pcard sector: sector=%d count=%d len=%d" % (sector, nsector, len(buffer)))
  237.         
  238.         if not self.channel_opened:
  239.             self.open_channel()
  240.  
  241.  
  242.         sectors_to_write = range(sector, sector+nsector)
  243.         request = struct.pack('!HHH' + 'I'*nsector, WRITE_CMD, nsector, 0, *sectors_to_write)
  244.         request = ''.join([request, buffer])
  245.  
  246.         if self.callback is not None:
  247.             self.callback()
  248.  
  249.         self.device.writePCard(request)
  250.         data = self.device.readPCard(2)
  251.  
  252.         if self.callback is not None:
  253.             self.callback()
  254.  
  255.         code = struct.unpack('!H', data)[0]
  256.  
  257.         if code != NAK:
  258.             if self.cache_flag:
  259.                 i = 0
  260.                 for s in range(sector, sector+nsector):
  261.                     log.debug("Caching sector %d" % sector)
  262.                     self.sector_buffer[s] = buffer[i:i+SECTOR_SIZE]
  263.                     self.sector_buffer_counts[s] = 1
  264.                     i += SECTOR_SIZE
  265.  
  266.                 if self.callback is not None:
  267.                     self.callback()    
  268.  
  269.                 self._check_cache(nsector)
  270.  
  271.             return 0
  272.  
  273.         else:    
  274.             if self.cache_flag:
  275.                 for s in range(sector, sector+nsector):
  276.                     try:
  277.                         del self.sector_buffer[s]
  278.                         del self.sector_buffer_counts[s]
  279.                     except KeyError:
  280.                         pass
  281.  
  282.             log.error("Photo card write failed (Card may be write protected)")
  283.             self.close_channel()
  284.             return 1
  285.  
  286.  
  287.     def _check_cache(self, nsector):
  288.         if len(self.sector_buffer) > MAX_CACHE:
  289.             # simple minded: scan for first nsector sectors that has count of 1 and throw it away
  290.             t, n = self.sector_buffer.keys()[:], 0
  291.             for s in t:
  292.                 if self.sector_buffer_counts[s] == 1:
  293.                     del self.sector_buffer[s]
  294.                     del self.sector_buffer_counts[s]
  295.                     n += 1
  296.                     if n >= nsector:
  297.                         break
  298.                     if self.callback is not None:
  299.                         self.callback()
  300.  
  301.  
  302.  
  303.     def cache_info(self):
  304.         return self.sector_buffer_counts
  305.  
  306.     def cache_check(self, sector):
  307.         return self.sector_buffer_counts.get(sector, 0)
  308.  
  309.     def cache_control(self, control):
  310.         self.cache_flag = control
  311.  
  312.         if not self.cache_flag:
  313.             self.cache_reset()
  314.  
  315.     def cache_state(self):
  316.         return self.cache_flag
  317.  
  318.     def cache_reset(self):
  319.         self.sector_buffer.clear()
  320.         self.sector_buffer_counts.clear()
  321.  
  322.     def df(self):
  323.         df = 0
  324.         self.START_OPERATION('df')
  325.         try:
  326.             df = pcardext.df()
  327.         finally:
  328.             self.END_OPERATION('df')
  329.             return df
  330.  
  331.     def ls(self, force_read=True, glob_list='*', openclose=True):
  332.         if not glob_list:
  333.             glob_list = '*'
  334.         if force_read:
  335.             self.START_OPERATION('ls')
  336.             try:
  337.                 self.current_dir = pcardext.ls()
  338.             finally:
  339.                 self.END_OPERATION('ls', openclose)
  340.  
  341.         self.current_dir = [(n.lower(),a,s) for (n,a,s) in self.current_dir]
  342.  
  343.         if glob_list == '*':
  344.             return self.current_dir
  345.  
  346.         return [fnmatch.filter(self.current_dir, x) for x in glob_list.strip().lower().split()][0]
  347.  
  348.     def size(self, name):
  349.         for f in self.current_dir:
  350.             if f == name:
  351.                 return self.current_dir[f][2]
  352.         return 0
  353.  
  354.     def current_files(self):
  355.         return [x for x in self.current_dir if x[1] != 'd']
  356.  
  357.     def current_directories(self):
  358.         return [x for x in self.current_dir if x[1] == 'd']
  359.  
  360.     def match_files(self, glob_list):
  361.         if len(glob_list) > 0:
  362.             current_files = [x[0] for x in self.current_files()]
  363.             return [fnmatch.filter(current_files, x) for x in glob_list.strip().lower().split()][0]
  364.         return []
  365.  
  366.     def match_dirs(self, glob_list):
  367.         if len(glob_list) > 0:
  368.             current_dirs = [x[0] for x in self.current_directories()]
  369.             return [fnmatch.filter(current_dirs, x) for x in glob_list.strip().lower().split()][0]
  370.         return []
  371.  
  372.     def classify_file(self, filename):
  373.         t = mimetypes.guess_type(filename)[0]
  374.         if t is None:
  375.             return 'unknown/unknown'
  376.         return t
  377.  
  378.     # copy a single file fom pwd to lpwd
  379.     def cp(self, name, local_file, openclose=True):
  380.         self.START_OPERATION('cp')
  381.         total = 0
  382.         try:
  383.             f = file(local_file, 'w');
  384.             total = pcardext.cp(name, f.fileno())
  385.             f.close()
  386.         finally:
  387.             self.END_OPERATION('cp', openclose)
  388.             return total
  389.  
  390.     # cp multiple files in the current working directory
  391.     def cp_multiple(self, filelist, remove_after_copy, cp_status_callback=None, rm_status_callback=None):
  392.         delta, total = 0, 0
  393.         self.START_OPERATION('cp_multiple')
  394.         t1 = time.time()
  395.         try:
  396.             for f in filelist:
  397.  
  398.                 size = self.cp(f, f, False)
  399.  
  400.                 if cp_status_callback:
  401.                     cp_status_callback(os.path.join(self.pwd(), f), os.path.join(os.getcwd(), f), size)
  402.  
  403.                 total += size
  404.  
  405.  
  406.                 if remove_after_copy:
  407.                     pcardext.rm(f)
  408.  
  409.             t2 = time.time()
  410.             delta = t2-t1
  411.         finally:
  412.             if remove_after_copy:
  413.                 self.ls(True, '*', False)
  414.             self.END_OPERATION('cp_multiple')
  415.             return (total, delta)
  416.  
  417.     # cp multiple files with paths
  418.     def cp_list(self, filelist, remove_after_copy, cp_status_callback=None, rm_status_callback=None):
  419.         self.save_wd()
  420.         delta, total = 0, 0
  421.         self.START_OPERATION('cp_list')
  422.         t1 = time.time()
  423.         try:
  424.             for f in filelist:
  425.  
  426.                 path_list = f.split('/')[:-1]
  427.                 filename = f.split('/')[-1]
  428.  
  429.                 for p in path_list:
  430.                     self.cd(p, False)
  431.  
  432.                 size = self.cp(filename, filename, False)
  433.  
  434.                 if cp_status_callback is not None:
  435.                     cp_status_callback(f, os.path.join(os.getcwd(), filename), size)
  436.  
  437.                 total += size    
  438.  
  439.                 if remove_after_copy:
  440.                     pcardext.rm(filename)
  441.  
  442.                     if rm_status_callback is not None:
  443.                         rm_status_callback(f)
  444.  
  445.                 self.cd('/', False)
  446.  
  447.             t2 = time.time()
  448.             delta = t2-t1
  449.         finally:
  450.             #if remove_after_copy:
  451.             #    self.ls( True, '*', False )
  452.             self.restore_wd()
  453.             self.END_OPERATION('cp_list')
  454.             return (total, delta)
  455.  
  456.  
  457.  
  458.     def cp_fd(self, name, fd):
  459.         total = 0
  460.         self.START_OPERATION('cp_fd')
  461.         try:
  462.             total = pcardext.cp(name, fd)
  463.         finally:
  464.             self.END_OPERATION('cp_fd')
  465.             return total
  466.  
  467.  
  468.     def unload(self, unload_list, cp_status_callback=None, rm_status_callback=None, dont_remove=False):
  469.         was_cancelled = False
  470.         self.save_wd()
  471.         self.START_OPERATION('unload')
  472.         total = 0
  473.         t1 = time.time()
  474.  
  475.         for f in unload_list:
  476.             if not was_cancelled:
  477.                 name, size, typ, subtyp = f
  478.  
  479.                 p = name.split('/')
  480.                 dirs = p[:-1]
  481.                 filename = p[-1]
  482.                 self.cd('/', False)
  483.  
  484.                 if cp_status_callback is not None:
  485.                     if cp_status_callback(os.path.join(self.pwd(), filename), 
  486.                                             os.path.join(os.getcwd(), filename), 0):
  487.                         was_cancelled = True
  488.                         break
  489.  
  490.                 if len(dirs) > 0:
  491.                     for d in dirs:
  492.                         self.cd(d, False)
  493.  
  494.                 if os.path.exists(os.path.join(os.getcwd(), filename)):
  495.                     i = 2
  496.  
  497.                     while True:
  498.                         if not os.path.exists(os.path.join(os.getcwd(), filename + " (%d)" % i)):
  499.                             break
  500.  
  501.                         i += 1
  502.  
  503.                     total += self.cp(filename, filename + " (%d)" % i, False)
  504.  
  505.                 else:    
  506.                     total += self.cp(filename, filename, False)
  507.  
  508.                 if cp_status_callback is not None:
  509.                     if cp_status_callback(os.path.join(self.pwd(), filename), 
  510.                                             os.path.join(os.getcwd(), filename), size):
  511.                         was_cancelled = True
  512.                         break
  513.  
  514.                 if not dont_remove:
  515.                     if rm_status_callback is not None:
  516.                         rm_status_callback(os.path.join(self.pwd(), filename))
  517.  
  518.                     self.rm(filename, False, False)
  519.  
  520.  
  521.         t2 = time.time()
  522.         self.restore_wd(False)
  523.         self.ls(True, '*', False)
  524.         self.END_OPERATION('unload')
  525.  
  526.         return total, (t2-t1), was_cancelled
  527.  
  528.  
  529.     def get_unload_list(self):
  530.         tree = self.tree()
  531.         return self.__build_unload_list(tree)
  532.  
  533.  
  534.     def __build_unload_list(self, tree, path=None, out=None): 
  535.         if path is None:
  536.             out = []
  537.             path = utils.Stack()
  538.         for d in tree:
  539.             if type(tree[d]) == type({}):
  540.                 path.push(d)
  541.                 self.__build_unload_list(tree[d], path, out) 
  542.                 path.pop()
  543.             else:
  544.                 typ, subtyp = self.classify_file(d).split('/')
  545.                 if typ in ['image', 'audio', 'video']:
  546.                     p = path.as_list()
  547.                     name = '/'.join(['/'.join(p), d])
  548.                     out.append((name, tree[d], typ, subtyp)) 
  549.  
  550.         return out
  551.  
  552.  
  553.     def info(self):
  554.         return pcardext.info()
  555.  
  556.  
  557.     def cd(self, dirs, openclose=True):
  558.         self.START_OPERATION('cd')
  559.         try:
  560.             stat = pcardext.cd(dirs)
  561.             if stat:
  562.                 if dirs == '/':
  563.                     self.dir_stack.clear()
  564.  
  565.                 else:
  566.                     dirs = dirs.split('/')
  567.                     for d in dirs:
  568.                         self.dir_stack.push(d)
  569.  
  570.                 self.ls(True, '*', False)
  571.  
  572.         finally:
  573.             self.END_OPERATION('cd', openclose)
  574.  
  575.  
  576.     def cdup(self, openclose=True):
  577.         if len(self.dir_stack.as_list()) == 0:
  578.             return self.cd('/', openclose)
  579.  
  580.         self.dir_stack.pop()
  581.         self.START_OPERATION('cdup')
  582.         try:
  583.             pcardext.cd('/')
  584.  
  585.             for d in self.dir_stack.as_list():
  586.                 pcardext.cd(d)
  587.  
  588.             self.ls(True, '*', False)
  589.         finally:
  590.             self.END_OPERATION('cdup', openclose)
  591.  
  592.     def rm(self, name, refresh_dir=True, openclose=True):
  593.         self.START_OPERATION()
  594.         try:
  595.             r = pcardext.rm(name)
  596.  
  597.             if refresh_dir:
  598.                 self.ls(True, '*', False)
  599.         finally:
  600.             self.END_OPERATION(openclose)
  601.             return r
  602.  
  603.     def mount(self):
  604.         log.debug("Mounting photocard...")
  605.         self.START_OPERATION('mount')
  606.         try:
  607.             stat = pcardext.mount(self._read, self._write)
  608.             disk_info = pcardext.info()
  609.             self.write_protect = disk_info[8]
  610.             log.debug("stat=%d" % stat)
  611.  
  612.             if stat == 0:
  613.                 if self.write_protect:
  614.                     # if write_protect is True,
  615.                     # card write NAK'd and channel was 
  616.                     # closed. We have to reopen here.
  617.                     self.open_channel()
  618.  
  619.                 self.pcard_mounted = True
  620.                 pcardext.cd('/')
  621.  
  622.                 self.ls(True, '*', False)
  623.  
  624.             else:
  625.                 self.pcard_mounted = False
  626.                 raise Error(ERROR_DEVICE_DOES_NOT_SUPPORT_OPERATION)
  627.         finally:
  628.             if self.pcard_mounted:
  629.                 self.END_OPERATION('mount')
  630.  
  631.  
  632.  
  633.     def pwd(self):
  634.         return '/' + '/'.join(self.dir_stack.as_list())
  635.  
  636.  
  637.     def save_wd(self):
  638.         self.saved_pwd = self.dir_stack.as_list()[:]
  639.  
  640.     def restore_wd(self, openclose=True):
  641.         self.cd('/', openclose)
  642.         for d in self.saved_pwd:
  643.             self.cd(d, openclose)
  644.  
  645.  
  646.     def tree(self):
  647.         self.START_OPERATION('tree')
  648.         dir_tree = {}
  649.         try:
  650.             self.save_wd()
  651.             dir_tree = self.__tree()
  652.             self.restore_wd(False)
  653.         finally:
  654.             self.END_OPERATION('tree')
  655.             return dir_tree
  656.  
  657.     def __tree(self, __d=None):
  658.         if __d is None:
  659.             __d = {}
  660.             pcardext.cd('/')
  661.  
  662.         for f in pcardext.ls(): # True, '*', False ):
  663.             fname = f[0].lower()
  664.  
  665.             if self.callback is not None:
  666.                 self.callback()
  667.  
  668.             if fname not in ('.', '..'):
  669.                 if f[1] == 'd':
  670.                     self.cd(fname, False)
  671.                     __d[fname] = {}
  672.                     __d[fname] = self.__tree(__d[fname])
  673.                     self.cdup(False)
  674.  
  675.                 else:
  676.                     __d[fname] = f[2]
  677.  
  678.         return __d
  679.  
  680.  
  681.     def get_exif(self, name):
  682.         exif_info = {}
  683.         self.START_OPERATION('get_exif')
  684.         pcf = None
  685.         try:
  686.             pcf = PhotoCardFile(self, name)
  687.             exif_info = exif.process_file(pcf)
  688.         finally:    
  689.             if pcf is not None:
  690.                 pcf.close()
  691.             self.END_OPERATION('get_exif')
  692.             return exif_info
  693.  
  694.  
  695.     def get_exif_path(self, name):
  696.         exif_info = {}
  697.         self.START_OPERATION('get_exif_path')
  698.         self.save_wd()
  699.         try:
  700.             path_list = name.split('/')[:-1]
  701.             filename = name.split('/')[-1]
  702.  
  703.             for p in path_list:
  704.                 self.cd(p, False)
  705.  
  706.             pcf = PhotoCardFile(self, filename)
  707.             exif_info = exif.process_file(pcf)
  708.  
  709.         finally:    
  710.             self.restore_wd(False)
  711.             pcf.close()
  712.             self.END_OPERATION('get_exif_path')
  713.             return exif_info
  714.  
  715.  
  716.  
  717.     def sector(self, sector):
  718.         self.START_OPERATION('sector')
  719.         try:
  720.             data = self._read(sector, 1)
  721.         finally:
  722.             self.END_OPERATION('sector')
  723.             return data
  724.  
  725.     def umount(self):
  726.         pcardext.umount()
  727.         self.pcard_mounted = False
  728.  
  729.     def open_channel(self):
  730.         self.channel_opened = True
  731.         self.device.openPCard()
  732.  
  733.     def close_channel(self):
  734.         self.channel_opened = False
  735.         self.device.closePCard()
  736.  
  737.  
  738.  
  739.  
  740.  
  741.  
  742.